
/*
*Pool Public Licence version 0.1 or later
*Released on 20th April 2008.
*Any voilations can be repoted at paritosh@wikiocean.net
*What is treated as voilations can be found at www.wikiocean.net/ppl1-voilations* 
******************************************************************************
* The contents of this file are subject Affero GPL v3 and later with additional conditions.
* The additional conditions are to be considered as part of the Affero GPL v3 and later.
* The additional conditions will supersede the Affero GPLv3 and later in case of conflict.
* ("License"); You may not use this file except in compliance with the License
* You may obtain a copy of the License at http://www.gnu.org/licenses/agpl.html
* Software distributed under the License is distributed on an "AS IS" basis,
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for
* the specific language governing rights and limitations under the License.
* The Initial Developer of the Original Code is Paritosh Pungaliya.
* created by Paritosh Pungaliya are Copyright (C) Paritosh Pungaliya; All Rights Reserved.
* Contributions are Copyright (C) 2001-2008 Paritosh Pungaliya.

* Objective of the additional terms (license) 
* 1) Is to extend the software freedom to freedom to work.
* 2) To ensure that knowledge is free from monopoly of agencie(s).
* 3) To avoid a situation where big corporates or investors can buy out free software groups and companies and then start milking the communities built around it.
* (this trend can be seen how the openness changes in companies that get Venture Capital funding.)
* (if you agree to this logic I invite you to our group to work together)

* Additional conditions
*  0) Source code will also include
* 	a) data dictionaries, data ontologies which are used to alter the behavior of code or to control           the features of application.
* 	b) Any code generated or derived automatically or manually from this code or logic
*  1) The revenue generated by deploying, implementing , selling services and other activities
*  	 based on this source code should be shared 100%, between the people working on it.
*  2) Capital invested should be given only fixed rate of return or linked to revenue/surplus growth for limited time.
*  3) People working on the project should always have an option to replace the capital provider in full or part with lower cost capital.
*  4) Their should not be any ownership which can be sold as a claim on future profit to be generated from the work of people working on the code.
*  5) Brand thus generated should belong to the group.
*  6) For old and new members revenue sharing should be equal for same work equivalent.
*  7) The share of revenue should be decided by bidding for work before allocation of work within the group.
*  8) Before bidding various method of measuring the work should be clearly defined and published in public domain. Any change in process should also be publised in public domain imediately.
*  9) All data related to to revenue sharing should be published as and when generated in public domain.
*  10) For group of people having size more than 10 people will have to make it open online for others to participate in bids. 
*  11) All people involved in related and sub project will be treated as a group.
*  12) Once this license is being used for a certain code then all and any other software services being provided by the group should complusorilly come under 100% revenue sharing.
*  13) Cross subsidization should not happen under this revenue share, no additional benefit should be drawn from the people, by the employing agency.
*  14) Any position or knowledge or legal structure created relating to people working on code, which adversely affects the spirit of 100% revenue share will be treated as a violation.
*  15) Revenue sharing defined.
*     a) includes direct revenue and also intangible gains like brand, and organization.
*     b) No personal judgment should be involved in judging the distribution of revenue.It has to be pre-defined formula based.
*     c)100% of revenue should be shared before expenses and recievers should have control over what expenses to incur.
*     d)For the work done in any month by contributing group member, working on any project can be given revenue share from the work done by the group, for a maximum of 18 months after that month.
*     e)Revenue should be apportioned to the month in which work is done and not when received.
*  The group fulfilling the above conditions also has to be a wiki ecosystem further defined in www.wekosystem.org or read about Wekosystem at www.wikiocean.net

*  ******************************************************************************
*/  
package tablization;

public class dumpTemp
{
	 /*public static void main(String[] args) 
	{
		DBManager sqldb = new DBManager();
		sqldb.getConnect();
		
		TablizationManager tm = new TablizationManager(sqldb);
		
		String noOfObjects = "3";
		String object = "student";
		
		tm.createTablization(object,noOfObjects);
		Vector<Object> midVector = tm.getMid(object);
		
		if(midVector.size() > noOfObjects)
		{
			
			String [] objectArray = tm.getPropertyList(object);
			
			boolean flag=tm.getPropertyVector(objectArray);		
			
			TableCreation tc = new TableCreation(sqldb);
			
			//for unique properties boolean value will always be false
			if(!tm.uniqueVector.isEmpty())
				tc.createTable(midVector,tm.uniqueVector,false);
			
			if(!tm.multipleVector.isEmpty())
				tc.createTable(midVector,tm.multipleVector,flag);
			
		}
	}*/
	 //this is done for temporary
	/* public boolean getPropertyVector(Vector<Object> vector,int noOfObjects)
	 {
		 Vector< Object> tempVector = vector;				 
		
		 boolean boolMultiple = false;		
 		 
		 if(tempVector.size()>=noOfObjects)
			// for(int i=0; i<vector.size(); i++)
			 {
				 String objMid = tempVector.get(0).toString();
				 String path = TABLEPATH  + objMid + "//" + objMid + "_mid" + FILEFORMAT;
				 
				 Hashtable<Object,Object> tableHash = new Hashtable<Object, Object>();
				 tableHash.put("mid",objMid);
				 
				 sr = new SearchRecord(path);
				 String []strArray = sr.getRecordSet(tableHash);
				 
				 for(int j=0; j<strArray.length; j++)
				 {
					 String objPid = strArray[j].split("\t")[1];
					 for(int k=0; k<strArray.length; k++)
					 {
						 String tempPid = strArray[k].split("\t")[1];
						 if(j!= k)
						 {						 
							 if(objPid.equals(tempPid))
							 {
								 boolMultiple = true;
							 }
						 }
					 }
					 Hashtable< Object,Object> tempHash = new Hashtable<Object, Object>();
					 tempHash.put("pid",objPid);
					 if(boolMultiple == false)
					 {					
						 uniqueVector.add(tempHash);
					 }
					 else
					 {					 
						 if(!multipleVector.contains(tempHash))
							 	multipleVector.add(tempHash);
					 }
				 }
			 }
		 
		 return boolMultiple;
	 }*/
	
	/**
	 * this function creates table for given common set of properties of multiple objects
	 * @param objects - contains vector of object ids for which table is to be created
	 * @param properties - contains vector of properties on which table is to be created
	 * @param condition - contains boolean value to set condition of having unique or multiple properties
	 */
	/*public void createTable(Vector<Object> objects,Vector<Object> properties,boolean condition)
	{
		ResultSet rs;
		
		Hashtable<Object,Object> hasht=new Hashtable<Object, Object>();
	
		Vector<Object> deleteVector ;
		Vector<Object> columnVector=new Vector<Object>();	
		Vector<Object> insertVector=new Vector<Object>();
		
		columnVector.add(0,"id");
		//get the name of new table
		String tableName=getTableName();
		
		insertVector.add(getHashtable(tableName,column,"id"));
		insertVector.add(getHashtable(tableName,"type","table"));
		
		for(int i=0;i<properties.size();i++)
		{
			Hashtable<Object,Object> h=(Hashtable<Object, Object>)properties.get(i);
			String tempPid=h.get("pid").toString();			
			String tempColumn=gin.getItem(tempPid);				
			columnVector.add(i+1,tempColumn.toLowerCase());
			
			insertVector.add(getHashtable(tableName,column,tempColumn));
		}
		
		//creates table in database
		sqlDB.createTable(tableName, columnVector);
		
		// to be inserted in master
		callInsertMasterBean(tableName);
		
		// to be inserted in pl
		callInsertPropertyBean(insertVector);				
		
		try
		{
			insertVector=new Vector<Object>();
			
			for(int i=0;i<objects.size();i++)
			{					
				hasht=new Hashtable<Object, Object>();
				deleteVector = new Vector<Object>();
				
				String strMid=objects.get(i).toString();				
				
				String query="select mid,pid,pv,vt,ref from property_details where mid='"+strMid+"' order by pid";
				rs=sqlDB.getSelect(query);
				
				while(rs.next())
				{
					String rsPid = rs.getString("pid");
					for(int j=0;j<properties.size();j++)
					{
					
						Hashtable<Object, Object> tempHash = (Hashtable<Object, Object>)properties.get(j); 
						String pid = tempHash.get("pid").toString();					
						
						if(rsPid.equals(pid))
						{
							hasht.put(columnVector.get(0).toString(),strMid);
							
							String strPv=rs.getString("pv");					
							if(!strPv.equals("0"))
								strPv=gin.getItem(strPv);
							else
								strPv=rs.getString("vt");
							
							hasht.put(tableName+"."+columnVector.get(j+1).toString(), strPv);
							
							String strRef=rs.getString("ref");
							if(!strRef.equals("0"))
							{
								String tempPid=gin.getItem(pid);
								String queryRef="alter table "+tableName+" add column "+tempPid+"_ref longtext";
								sqlDB.getExecute(queryRef);
								strRef=gin.getItem(strRef);												
								hasht.put(tempPid+"_ref",strRef);								
							}							
							
							deleteVector.add(getHashtable(strMid, pid, strPv));
							
							if(condition == true)
							{
								sqlDB.getInsert(tableName, hasht);
								hasht = new Hashtable<Object, Object>();
							}
						}						
					}					
				}
				
				//to insert values in created table
				if(!hasht.isEmpty() && condition != true)
						sqlDB.getInsert(tableName, hasht);	
				
				//to delete properties from pl
				if(!deleteVector.isEmpty())
						callDeletePropertyBean(deleteVector);
				
				//adding type-tablization to mid				
				insertVector.add(getHashtable(strMid,tablization,tableName));
				
				//adding storage-db to mid
				//insertVector.add(getHashtable(strMid,"storage","database"));
			}
			
			//to add properties belonging to tablization in given objects
			callInsertPropertyBean(insertVector);
			
			System.out.println("Table created successfully");
		}		
		catch (Exception e) {
			// TODO: handle exception
		}								
	}
	*/
	
	/**
	 * this function works like select function of database & displays in a string format
	 * @param hashtable - containing conditions on which selection to be done
	 * @return - string containing message as per given conditions  
	 */
	//	temporary work
	/*public String getView(Hashtable<Object,Object> hashtable)
	{ 
		
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		String message = "",masterName ="",name="";		
		String mid = hashtable.get("mid").toString();		
		
		//get array of table which contains this mid
		String [] tableArray = getTableArray(mid);
		Vector<Object> propertyVector = new Vector<Object>();
		
		if(tableArray.length != 0)
		{
			//get properties from tablized tables
			Hashtable<Object,Object> tempHash = getTablizedHashtable(hashtable);
			for(int i=0;i<tableArray.length;i++)
			{				
				String tablename = tableArray[i].split(Input.SEPARATOR)[2];
				tablename  = gin.getItem(tablename);
				propertyVector.addAll(sqlDB.getSelectVector(tempHash, tablename));
			}	
		}
			
		StringBuilder strbdr = new StringBuilder();		
		
		for(int i=0;i<propertyVector.size();i++)
		{
			Hashtable<Object,Object> hasht = (Hashtable<Object, Object>)propertyVector.get(i);	
			name = gin.getItem(hasht.get("id").toString());
			if(!masterName.equalsIgnoreCase(name))
			{				
				strbdr.append(name);
				masterName  = name;
			}
			
			hasht.remove("id");
			//changes hashtable into string message format
			String master=convertToMessage("property_details","add", hasht);				
			strbdr.append(master);				
		}
		
		message = strbdr.toString();
		 timer.end();	
		 @SuppressWarnings("unused")
		TimerRecordFile timerFile=new TimerRecordFile("tablization","SearchingPropeties","getView",timer.duration());
	
		 return message;
	}*/
	

	/**
	 * this function checks whether table exists or not for given object name
	 * @param typeObject - name of object for which table is present or not 
	 * @return true if table exists
	 */
	/*public boolean checkTableExistence(String typeObject)
	{
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		 String []tableArray;
			boolean flag = false;
		
			String pidName = gin.getId("object");
			String path = Input.MASTERREPORTSPATH + pidName + "//" + pidName + "_pid" + Input.FILRFORMAT;
			 
			 Hashtable<Object,Object> tableHash = new Hashtable<Object, Object>();
			 tableHash.put("pv",gin.getId(typeObject));
			 
			 sr = new SearchRecord(path);			
			tableArray= sr.getRecordSet(tableHash);
			 
			 if(tableArray.length != 0)
			 {
				 System.out.println("Table exists");
				 flag= true;
			 }
			 else
			 {
				 System.out.println("Table doesnot exist");
			 }	
			 
			 timer.end();
			 @SuppressWarnings("unused")
			TimerRecordFile timerFile=new TimerRecordFile("tablization","SubTable","checkTableExistence",timer.duration());				
		
		return flag;
	}*/
	
	
		
	/**
	 * 
	 * @param hashtable
	 * @return
	 */
	/*public Hashtable<Object,Object> getTablizedHashtable(Hashtable<Object,Object> hashtable)
	{
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		Hashtable<Object,Object> hasht = new Hashtable<Object, Object>();
		
		String id = hashtable.get("mid").toString();
		hasht.put("id",id);
		String columnName = "",columnValue = "";
		try 
		{		
			columnName = gin.getItem(hashtable.get("pid").toString());			
		} 
		catch (Exception e) {		
		}
		
		try 
		{		
			 columnValue = gin.getItem(hashtable.get("pv").toString());	
			if(columnValue.equals("no$"))
				columnValue = hashtable.get("vt").toString();
		} 
		catch (Exception e) {			
		}		
		
		if(!columnName.equals("") && !columnValue.equals("no$"))
				hasht.put(columnName,columnValue);
		
		 timer.end();	
		 @SuppressWarnings("unused")
		 TimerRecordFile timerFile=new TimerRecordFile("tablization","SubTable","getTablizedHashtable",timer.duration());
		
		return hasht;
	}
	
	
	public Hashtable<Object,Object> getMasterHashtable(Hashtable<Object,Object> hashtable)
	{
		Hashtable<Object,Object> hasht = hashtable;
		
		String mid = hasht.get("id").toString();
		hasht.remove("id");
		Enumeration<Object> enumt = hasht.keys();
		while (enumt.hasMoreElements()) 
		{
			String pid = (String) enumt.nextElement();
			
		}
		
		
		
		return hasht;
	}*/
	/*public Hashtable<Object,Object> convertInMasterName(Hashtable<Object,Object> oldPropertyHash)
	{
		Hashtable<Object,Object> propertyHash = new Hashtable<Object, Object>();
		
		String tableName = "property_details";
		String process = "add";
		
		propertyHash.putAll(oldPropertyHash);
		propertyHash = gin.ConvertPVtoVT(propertyHash);
		propertyHash = gin.convertMasterId(propertyHash, tableName,process);
		
		return propertyHash;
	}*/
	
	
	/**
	 * this function returns array of tables belonging to particular object name
	 * @param midName - name of object for whom table array is to get
	 * @return string array of tables respective to given object name
	 */
	/*public String[] getMidTableArray(String midName)
	{
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		String []tableArray;
		
		String mid = midName;
				
			String pidName = gin.getId("tablization");
			String path = Input.MASTERREPORTSPATH + pidName + "//" + pidName + "_pid" + Input.FILRFORMAT;
			 
			 Hashtable<Object,Object> tableHash = new Hashtable<Object, Object>();
			 tableHash.put("mid",mid);
			 
			 sr = new SearchRecord(path);			
			 tableArray = sr.getRecordSet(tableHash);
			 
			 System.out.println();
			 System.out.println("Table Array Fetched");
			 
			 timer.end();
			 @SuppressWarnings("unused")
			 TimerRecordFile timerFile=new TimerRecordFile("tablization","SubTable","getMidTableArray",timer.duration());
			
		
		return tableArray;
	}*/
	
	
	/**
	 * this function returns array of tables which has given column name
	 * @param columnName - name of column for whom table array is to get
	 * @return string array of tables having respective given column name
	 */
	/*public String[] getColumnTableArray(String columnName)
	{
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		String []columnTableArray;
		
		String pv = columnName;
		String pidName = gin.getId("column");
		String path = Input.MASTERREPORTSPATH + pidName + "//" + pidName + "_pid" + Input.FILRFORMAT;
		 
		 Hashtable<Object,Object> tableHash = new Hashtable<Object, Object>();
		 tableHash.put("pv", pv);
		 
		 sr = new SearchRecord(path);			
		 columnTableArray = sr.getRecordSet(tableHash);
		 
		 System.out.println();
		 System.out.println("Table Array Fetched");
		
		 timer.end();
		 @SuppressWarnings("unused")
		 TimerRecordFile timerFile=new TimerRecordFile("tablization","SubTable","getColumnTableArray",timer.duration());
		
		return columnTableArray;
	}*/
	
	
	/**
	 * this function returns array of columns for given table name
	 * @param tableName - name of table for which column array to be get
	 * @return string array containing column names of given table
	 */
	/*public String[] getColumnArray(String tableName)
	{
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		String pidName = gin.getId("column");
		String path = Input.MASTERREPORTSPATH + pidName + "//" + pidName + "_pid" + Input.FILRFORMAT;
		 
		 Hashtable<Object,Object> tableHash = new Hashtable<Object, Object>();
		 tableHash.put("mid",tableName);
		 
		 sr = new SearchRecord(path);			
		 String [] columnArray= sr.getRecordSet(tableHash);
		 
		 System.out.println();
		 System.out.println("Column Array Fetched");
		
		 timer.end();	
		 @SuppressWarnings("unused")
		TimerRecordFile timerFile=new TimerRecordFile("tablization","SubTable","getColumnArray",timer.duration());
			
		 return columnArray;
	}*/
	
	
	/**
	 * this function returns array of table according to type of object
	 * @param typeObject - type of object whom table array is to get
	 * @return string array of tables having respective given type
	 */
	/*public String [] getObjectTableArray(String typeObject)
	{
		ExecutionTimer timer = new ExecutionTimer();
		timer.start();
		
		 	String []tableArray;
					
			String pidName = gin.getId("object");
			String path = Input.MASTERREPORTSPATH + pidName + "//" + pidName + "_pid" + Input.FILRFORMAT;
			 
			 Hashtable<Object,Object> tableHash = new Hashtable<Object, Object>();
			 tableHash.put("pv",gin.getId(typeObject));
			 
			 sr = new SearchRecord(path);			
			tableArray= sr.getRecordSet(tableHash);
			 
			 timer.end();
			 @SuppressWarnings("unused")
			TimerRecordFile timerFile=new TimerRecordFile("tablization","SubTable","getObjectTableArray",timer.duration());
				
		
		return tableArray;
	}*/
	
	
	/*private String[] checkTableExistence(String type)
	{
		
		Hashtable<Object,Object> arrayHash = new Hashtable<Object, Object>();				
		
		arrayHash.put(PID_NAME, "object");
		arrayHash.put(keyName, "pv");
		arrayHash.put(valueName, gin.getId(type));
		//to check whether tablization is done or not 
		String [] tableArray= getArray(arrayHash);
		
	}*/
}
